pyegeria 5.4.0.28__py3-none-any.whl → 5.5.3.3__py3-none-any.whl

commands/__init__.py

@@ -0,0 +1,24 @@
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+
+
+pyegeria md_commands available also from python.
+"""
+from .cat.dr_egeria_md import process_markdown_file
+from .cat.list_deployed_catalogs import list_deployed_catalogs
+from .cat.list_deployed_database_schemas import list_deployed_database_schemas
+from .cat.list_deployed_databases import list_deployed_databases
+from .cat.list_glossaries import display_glossaries
+from .cat.list_terms import display_glossary_terms
+from .ops.list_catalog_targets import display_catalog_targets
+from .ops.monitor_engine_activity import display_engine_activity_c
+from .ops.monitor_engine_status import display_gov_eng_status
+from .ops.monitor_daemon_status import display_integration_daemon_status
+from .ops.table_integ_daemon_status import (
+    display_integration_daemon_status as table_integ_daemon_status,
+)
+
+
+

commands/cat/Dr-Egeria_md-orig.py

@@ -6,8 +6,8 @@ import os
 from rich import print
 from rich.console import Console
 
-from pyegeria.md_processing_utils import (commands,
-                                          process_provenance_command)
+from pyegeria.view.md_processing_utils import (commands,
+                                               process_provenance_command)
 
 import click
 from pyegeria import (extract_command, process_glossary_upsert_command, process_term_upsert_command,

commands/cat/collection_actions.py

@@ -0,0 +1,197 @@
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+
+
+Execute Glossary actions.
+
+"""
+
+import os
+
+import click
+
+
+from pyegeria import (
+    EgeriaTech, body_slimmer, settings,
+    PyegeriaAPIException, PyegeriaClientException, print_basic_exception, print_exception_table
+)
+app_config = settings.Environment
+
+EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
+EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
+
+COLLECTION_TYPES = ["Collection", "Glossary", "CollectionFolder", "RootCollection", "WorkItemList", "SolutionBlueprint" ]
+
+
+@click.command("add-element-to-collection")
+@click.option("--element-guid", required=True, default = "",help="GUID of the element to add to a Collection")
+@click.option("--collection-guid", required=True, default = "", help="GUID of the Collection to add an element to")
+@click.option("--server", default=app_config.egeria_view_server, help="Egeria view server to use")
+@click.option(
+    "--url", default=app_config.egeria_view_server_url, help="URL of Egeria platform to connect to"
+)
+@click.option("--userid", default=EGERIA_USER, help="Egeria user")
+@click.option("--password", default=EGERIA_USER_PASSWORD, help="Egeria user password")
+@click.option("--timeout", default=60, help="Number of seconds to wait")
+
+
+def add_element_to_collection(server, url, userid, password, timeout, element_guid, collection_guid):
+    """Add a glossary term to a Collection"""
+    m_client = EgeriaTech(server, url, user_id=userid, user_pwd=password)
+    token = m_client.create_egeria_bearer_token()
+    try:
+        element_guid = element_guid.strip()
+        collection_guid = collection_guid.strip()
+        m_client.add_to_collection(element_guid, collection_guid)
+
+        click.echo(
+            f"Added element with GUID: {element_guid} to Collection with GUID: {collection_guid}\n"
+        )
+
+    except (PyegeriaAPIException, PyegeriaClientException) as e:
+        print_basic_exception(e)
+    finally:
+        m_client.close_session()
+
+@click.command("remove-element-from-collection")
+@click.option("--element-guid", required=True, default = "",help="GUID of the element to remove from the collection")
+@click.option("--collection-guid", required=True, default = "", help="GUID of collection to remove the element from")
+
+@click.option("--server", default=app_config.egeria_view_server, help="Egeria view server to use")
+@click.option(
+    "--url", default=app_config.egeria_view_server_url, help="URL of Egeria platform to connect to"
+)
+@click.option("--userid", default=EGERIA_USER, help="Egeria user")
+@click.option("--password", default=EGERIA_USER_PASSWORD, help="Egeria user password")
+@click.option("--timeout", default=60, help="Number of seconds to wait")
+
+def remove_element_from_collection(server, url, userid, password, timeout, element_guid, collection_guid):
+    """Remove an element from a Collection"""
+    m_client = EgeriaTech(server, url, user_id=userid, user_pwd=password)
+    token = m_client.create_egeria_bearer_token()
+    try:
+        element_guid = element_guid.strip()
+        collection_guid = collection_guid.strip()
+        body = {
+            "class": "DeleteRelationshipRequestBody"
+        }
+        m_client.remove_from_collection( collection_guid, element_guid, body)
+
+        click.echo(
+            f"Removed term with GUID: {element_guid} from Collection with GUID: {collection_guid}\n"
+        )
+
+    except (PyegeriaAPIException, PyegeriaClientException) as e:
+        print_basic_exception(e)
+    finally:
+        m_client.close_session()
+
+
+@click.command("create-collection")
+@click.option("--name", help="Collection Name",default = "", required=True)
+@click.option("--kind", help="Kind of Collection", default = "Collection",
+            type_name = click.Choice(COLLECTION_TYPES, case_sensitive=False))
+@click.option(
+    "--description",
+    help="Description of the Collection",
+    default="A description goes here",
+)
+@click.option(
+    "--category", default = "",
+    help="Category of the Collection"
+)
+@click.option("--server", default=app_config.egeria_view_server, help="Egeria view server to use.")
+@click.option(
+    "--url", default=app_config.egeria_view_server_url, help="URL of Egeria platform to connect to"
+)
+@click.option("--userid", default=EGERIA_USER, help="Egeria user")
+@click.option("--password", default=EGERIA_USER_PASSWORD, help="Egeria user password")
+@click.option("--timeout", default=60, help="Number of seconds to wait")
+def create_collection(
+    server: str,
+    url: str,
+    userid: str,
+    password: str,
+    timeout: int,
+    name: str,
+    kind: str,
+    description: str,
+    category: str,
+) -> None:
+    """Create a new Collection"""
+
+    try:
+        m_client = EgeriaTech(server, url, userid, password)
+        token = m_client.create_egeria_bearer_token()
+
+        collection_guid = m_client.create_collection( display_name = name, description = description, category = category,
+                                                      prop = [kind])
+        print(f"New categry \'{name}\' created with id of \'{collection_guid}\'")
+
+    except (PyegeriaAPIException, PyegeriaClientException) as e:
+        print_basic_exception(e)
+    finally:
+        m_client.close_session()
+
+
+@click.command("update-collection")
+@click.option("--name", help="Collection Name", default = "",required=False)
+@click.option("--description", default = "",help="Description of the Collection")
+@click.option("--category", default = "", help="Category of the Collection")
+@click.option("--server", default=app_config.egeria_view_server, help="Egeria view server to use")
+@click.option(
+    "--url", default=app_config.egeria_view_server_url, help="URL of Egeria platform to connect to"
+)
+@click.option("--userid", default=EGERIA_USER, help="Egeria user")
+@click.option("--password", default=EGERIA_USER_PASSWORD, help="Egeria user password")
+@click.option("--timeout", default=60, help="Number of seconds to wait")
+@click.argument("collection-guid")
+
+def update_collection(collection_guid, name, description, category, server, url, userid, password, timeout, ):
+    """Update the collection specified"""
+    m_client = EgeriaTech(server, url, user_id=userid, user_pwd=password)
+    token = m_client.create_egeria_bearer_token()
+    try:
+        body = {
+          "class" : "UpdateElementRequestBody",
+          "properties": {
+            "class" : "CollectionProperties",
+            "name" : name,
+            "description" : description,
+            "category": category
+          },
+        }
+        m_client.update_collection(collection_guid, body_slimmer(body))
+
+        click.echo(f"Updated glossary: {collection_guid}")
+
+    except (PyegeriaAPIException, PyegeriaClientException) as e:
+        print_basic_exception(e)
+    finally:
+        m_client.close_session()
+
+@click.command("delete-collection")
+@click.argument("collection-guid")
+@click.option("--server", default=app_config.egeria_view_server, help="Egeria view server to use")
+@click.option(
+    "--url", default=app_config.egeria_view_server_url, help="URL of Egeria platform to connect to"
+)
+@click.option("--userid", default=EGERIA_USER, help="Egeria user")
+@click.option("--password", default=EGERIA_USER_PASSWORD, help="Egeria user password")
+@click.option("--timeout", default=60, help="Number of seconds to wait")
+
+def delete_collection(server, url, userid, password, timeout, collection_guid):
+    """Delete the collection specified"""
+    m_client = EgeriaTech(server, url, user_id=userid, user_pwd=password)
+    token = m_client.create_egeria_bearer_token()
+    try:
+        m_client.delete_collection(collection_guid)
+
+        click.echo(f"Deleted collection: {collection_guid}")
+
+    except (PyegeriaAPIException, PyegeriaClientException) as e:
+        print_basic_exception(e)
+    finally:
+        m_client.close_session()

commands/cat/dr_egeria_command_help.py

@@ -11,21 +11,31 @@ import os
 import sys
 import time
 
+from pydantic import ValidationError
 from rich import box
 from rich.console import Console
 from rich.markdown import Markdown
 from rich.prompt import Prompt
 from rich.table import Table
 from rich.text import Text
+from typing import List
+from html import escape
+try:
+    from markdown_it import MarkdownIt
+except Exception:
+    MarkdownIt = None
 
 from pyegeria import (
     EgeriaTech,
-    InvalidParameterException,
-    PropertyServerException,
-    UserNotAuthorizedException, NO_CATEGORIES_FOUND,
-    )
-from commands.cat.glossary_actions import EGERIA_HOME_GLOSSARY_GUID
-from pyegeria._globals import NO_GLOSSARIES_FOUND
+    PyegeriaException, print_basic_exception, print_validation_error,
+)
+from pyegeria.core._exceptions import (
+    PyegeriaInvalidParameterException,
+    PyegeriaAPIException as PropertyServerException,
+    PyegeriaUnauthorizedException as UserNotAuthorizedException,
+)
+# Default glossary GUID can be provided via environment; fall back to None
+EGERIA_HOME_GLOSSARY_GUID = os.environ.get("EGERIA_HOME_GLOSSARY_GUID", None)
 
 disable_ssl_warnings = True
 
@@ -48,6 +58,40 @@ EGERIA_ROOT_PATH = os.environ.get("EGERIA_ROOT_PATH", "../../")
 EGERIA_INBOX_PATH = os.environ.get("EGERIA_INBOX_PATH", "md_processing/dr_egeria_inbox")
 EGERIA_OUTBOX_PATH = os.environ.get("EGERIA_OUTBOX_PATH", "md_processing/dr_egeria_outbox")
 
+def _get_console_width_from_config(default_width: int = EGERIA_WIDTH) -> int:
+    try:
+        from pyegeria.core.config import settings
+        return int(getattr(settings.Environment, "console_width", default_width) or default_width)
+    except Exception:
+        return default_width
+
+def _get_outbox_dir() -> str:
+    root = os.environ.get("EGERIA_ROOT_PATH", EGERIA_ROOT_PATH)
+    out = os.environ.get("EGERIA_OUTBOX_PATH", EGERIA_OUTBOX_PATH)
+    return os.path.join(root, out)
+
+def _md_to_html(md_text: str) -> str:
+    if not md_text:
+        return ""
+    if MarkdownIt is None:
+        return f"<pre>{escape(md_text)}</pre>"
+    try:
+        return MarkdownIt().render(md_text)
+    except Exception:
+        return f"<pre>{escape(md_text)}</pre>"
+
+def _build_html_table(columns: List[str], rows: List[List[str]]) -> str:
+    ths = ''.join(f'<th>{escape(c)}</th>' for c in columns)
+    body_rows = []
+    for r in rows:
+        tds = []
+        for cell in r:
+            if isinstance(cell, str) and cell.lstrip().startswith('<table'):
+                tds.append(f"<td>{cell}</td>")
+            else:
+                tds.append(f"<td>{escape(cell or '')}</td>")
+        body_rows.append('<tr>' + ''.join(tds) + '</tr>')
+    return '<table>\n<thead><tr>' + ths + '</tr></thead>\n<tbody>\n' + "\n".join(body_rows) + '\n</tbody>\n</table>'
 
 def display_command_terms(
     search_string: str = "*",
@@ -60,6 +104,7 @@ def display_command_terms(
     jupyter: bool = EGERIA_JUPYTER,
     width: int = EGERIA_WIDTH,
     output_format: str = "TABLE",
+    mode: str = "terminal",
 ):
     """Display a table of glossary terms filtered by search_string and glossary, if specified. If no
         filters then all terms are displayed. If glossary_guid or name is specified, then only terms from that
@@ -98,26 +143,18 @@ def display_command_terms(
     try:
         g_client = EgeriaTech(view_server, view_url, user_id, user_pass)
         token = g_client.create_egeria_bearer_token(user_id, user_pass)
-        if (glossary_name is not None) and (glossary_name != "*"):
-            glossary_guid = g_client.get_guid_for_name(glossary_name)
-            if glossary_guid == NO_GLOSSARIES_FOUND:
-                console.print(
-                    f"\nThe glossary name {glossary_name} was not found. Please try using the glossary guid"
-                )
-                sys.exit(1)
-        elif (glossary_guid is not None) and (len(glossary_guid) < 10):
-                glossary_guid = None
+
 
         if output_format == "LIST":
             action = "LIST"
         elif output_format == "REPORT":
             action = "Report"
         if output_format != "TABLE":
-            file_path = os.path.join(EGERIA_ROOT_PATH, EGERIA_OUTBOX_PATH)
+            file_path = _get_outbox_dir()
             file_name = f"Command-Help-{time.strftime('%Y-%m-%d-%H-%M-%S')}-{action}.md"
             full_file_path = os.path.join(file_path, file_name)
             os.makedirs(os.path.dirname(full_file_path), exist_ok=True)
-            output = g_client.find_glossary_terms(search_string, glossary_guid, output_format=output_format)
+            output = g_client.find_glossary_terms(search_string,  output_format=output_format, report_spec="Help-Terms")
             if output == "NO_TERMS_FOUND":
                 print(f"\n==> No commands found for search string '{search_string}'")
                 return
@@ -127,12 +164,13 @@ def display_command_terms(
             return
 
     except (
-        InvalidParameterException,
-        PropertyServerException,
-        UserNotAuthorizedException,
+        PyegeriaException
         ) as e:
-        console.print_exception()
-
+        print_basic_exception(e)
+    except ValidationError as e:
+        print_validation_error(e)
+    except Exception as e:
+        console.print_exception(e)
 
 
     def generate_table(search_string: str, glossary_guid: str) -> Table:
@@ -156,25 +194,21 @@ def display_command_terms(
 
         terms = g_client.find_glossary_terms(
             search_string,
-            glossary_guid,
-            starts_with=False,
-            ends_with=False,
-            status_filter=[],
             page_size=500,
         )
 
-        if type(terms) is str:
+        if isinstance(terms, str):
             print(f"No commands found - this was not the command you were looking for?! - {search_string} : {glossary_guid} ")
             sys.exit(0)
         sorted_terms = sorted(
-            terms, key=lambda k: k["glossaryTermProperties"].get("displayName","---")
+            terms, key=lambda k: (k.get("properties") or {}).get("displayName","---")
         )
         style = "bright_white on black"
         if type(terms) is str:
             return table
         glossary_info = {}
         for term in sorted_terms:
-            props = term.get("glossaryTermProperties", "None")
+            props = term.get("properties", "None")
             if props == "None":
                 return table
 
@@ -193,11 +227,9 @@ def display_command_terms(
             usage = props.get("usage", "---")
             # ex_us_out = Markdown(f"Example:\n{example}\n---\nUsage: \n{usage}")
 
-            classifications = term["elementHeader"]["classifications"]
+            classifications = term["elementHeader"].get("classifications",None)
             glossary_guid = None
-            for c in classifications:
-                if c["classificationName"] == "Anchors":
-                    glossary_guid = c["classificationProperties"]["anchorScopeGUID"]
+
 
             if glossary_guid and glossary_guid in glossary_info:
                 glossary_name = glossary_info[glossary_guid]
@@ -218,16 +250,77 @@ def display_command_terms(
                 Markdown(usage),
                 style="bold white on black",
             )
+            if not classifications:
+                continue
+            for c in classifications:
+                if c["classificationName"] == "Anchors":
+                    glossary_guid = c["classificationProperties"]["anchorScopeGUID"]
 
         g_client.close_session()
         return table
 
+    # Shared fetch for md modes
+    if mode in ("md", "md-html"):
+        try:
+            terms = g_client.find_glossary_terms(search_string, page_size=500)
+        except Exception:
+            terms = []
+        if isinstance(terms, str) and terms == "NO_TERMS_FOUND":
+            print(f"\n==> No commands found for search string '{search_string}'")
+            return
+        # Build outputs
+        out_dir = _get_outbox_dir()
+        os.makedirs(out_dir, exist_ok=True)
+        stamp = time.strftime('%Y-%m-%d-%H-%M-%S')
+        if mode == "md":
+            # Simple sections per term
+            lines: List[str] = []
+            lines.append(f"# Dr.Egeria Commands (search: `{search_string}`)")
+            lines.append("")
+            sorted_terms = sorted(terms, key=lambda t: (t.get("properties") or {}).get("displayName", "---"))
+            for term in sorted_terms:
+                props = term.get("properties") or {}
+                name = props.get("displayName", "---") or "---"
+                desc = props.get("description", "") or ""
+                usage = props.get("usage", "") or ""
+                lines.append(f"## {name}")
+                lines.append("")
+                lines.append("### Description\n")
+                lines.append(desc if desc.strip() else "_No description_")
+                lines.append("")
+                if usage.strip():
+                    lines.append("### Usage\n")
+                    lines.append(usage)
+                    lines.append("")
+                lines.append("---\n")
+            content = "\n".join(lines)
+            file_name = f"Command-Help-{stamp}-md.md"
+        else:
+            # md-html nested tables
+            columns = ["Command", "Description", "Usage"]
+            rows: List[List[str]] = []
+            sorted_terms = sorted(terms, key=lambda t: (t.get("properties") or {}).get("displayName", "---"))
+            for term in sorted_terms:
+                props = term.get("properties") or {}
+                name = props.get("displayName", "---") or "---"
+                desc = props.get("description", "") or ""
+                usage_md = props.get("usage", "") or ""
+                usage_html = _md_to_html(usage_md).strip()
+                rows.append([name, desc, usage_html])
+            content = f"# Dr.Egeria Commands (search: `{search_string}`)\n\n" + _build_html_table(columns, rows) + "\n"
+            file_name = f"Command-Help-{stamp}-md-html.md"
+        full_file_path = os.path.join(out_dir, file_name)
+        with open(full_file_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+        print(f"\n==> Help written to {full_file_path}")
+        return
+
     try:
         with console.pager(styles=True):
             console.print(generate_table(search_string, glossary_guid))
 
     except (
-        InvalidParameterException,
+        PyegeriaInvalidParameterException,
         PropertyServerException,
         UserNotAuthorizedException,
     ) as e:
@@ -242,6 +335,8 @@ def main():
     parser.add_argument("--userid", help="User Id")
     parser.add_argument("--password", help="User Password")
     parser.add_argument("--guid", help="GUID of glossary to search")
+    parser.add_argument("--mode", choices=["terminal","md","md-html"], default="terminal", help="Output mode: terminal (default) prints Rich table; md writes Markdown; md-html writes Markdown with HTML tables.")
+    parser.add_argument("--search", help="Search string for commands", default=None)
 
     args = parser.parse_args()
 
@@ -254,13 +349,17 @@ def main():
     guid = args.guid if args.guid is not None else EGERIA_HOME_GLOSSARY_GUID
 
     try:
-        search_string = Prompt.ask("Enter the command you are searching for:", default="*")
+        search_default = args.search or "*"
+        search_string = args.search or Prompt.ask("Enter the command you are searching for:", default=search_default)
 
-        output_format = Prompt.ask("What output format do you want?", choices=["TABLE", "LIST", "REPORT"], default="TABLE")
+        if args.mode == "terminal":
+            output_format = Prompt.ask("What output format do you want?", choices=["TABLE", "LIST", "REPORT"], default="TABLE")
+        else:
+            output_format = "TABLE"
 
         display_command_terms(
-        search_string, guid, 'Egeria-Markdown', server, url,
-            userid, user_pass, output_format= output_format
+            search_string, guid, 'Egeria-Markdown', server, url,
+            userid, user_pass, output_format=output_format, mode=args.mode
         )
 
     except KeyboardInterrupt:

commands/cat/dr_egeria_jupyter.py

@@ -8,13 +8,13 @@ from rich import print
 from rich.console import Console
 
 from pyegeria.egeria_tech_client import EgeriaTech
-from pyegeria.md_processing_utils import (extract_command, process_glossary_upsert_command, process_term_upsert_command,
-                                          get_current_datetime_string, process_per_proj_upsert_command, command_list,
-                                          )
+from pyegeria.view.md_processing_utils import (extract_command, process_glossary_upsert_command, process_term_upsert_command,
+                                               get_current_datetime_string, process_per_proj_upsert_command, command_list,
+                                               )
 import click
 
-from pyegeria._exceptions import (
-    print_exception_response,
+from pyegeria.core._exceptions import (
+    print_basic_exception, PyegeriaException,
 )
 
 EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
@@ -113,8 +113,8 @@ def process_jupyter_notebook(
         else:
             click.echo("\nNo updates detected. New file not created.")
 
-    except Exception as e:
-        print_exception_response(e)
+    except PyegeriaException as e:
+        print_basic_exception(e)
         return